home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.0 / PInterfaces / ImageCompression.p < prev    next >
Encoding:
Text File  |  1995-04-18  |  33.4 KB  |  864 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        ImageCompression.p
  3.  
  4.      Contains:    QuickTime Image Compression Interfaces.
  5.  
  6.      Version:    Technology:    QuickTime 2.0
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT ImageCompression;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __IMAGECOMPRESSION__}
  30. {$SETC __IMAGECOMPRESSION__ := 1}
  31.  
  32. {$I+}
  33. {$SETC ImageCompressionIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __QUICKDRAW__}
  43. {$I Quickdraw.p}
  44. {$ENDC}
  45. {    MixedMode.p                                                    }
  46. {    QuickdrawText.p                                                }
  47.  
  48. {$IFC UNDEFINED __QDOFFSCREEN__}
  49. {$I QDOffscreen.p}
  50. {$ENDC}
  51. {    Errors.p                                                    }
  52.  
  53. {$IFC UNDEFINED __COMPONENTS__}
  54. {$I Components.p}
  55. {$ENDC}
  56.  
  57. {$IFC UNDEFINED __WINDOWS__}
  58. {$I Windows.p}
  59. {$ENDC}
  60. {    Memory.p                                                    }
  61. {    Events.p                                                    }
  62. {        OSUtils.p                                                }
  63. {    Controls.p                                                    }
  64. {        Menus.p                                                    }
  65.  
  66. {$IFC UNDEFINED __STANDARDFILE__}
  67. {$I StandardFile.p}
  68. {$ENDC}
  69. {    Dialogs.p                                                    }
  70. {        TextEdit.p                                                }
  71. {    Files.p                                                        }
  72.  
  73. {$PUSH}
  74. {$ALIGN MAC68K}
  75. {$LibExport+}
  76.  
  77. TYPE
  78.     MatrixRecord = RECORD
  79.         matrix:                    ARRAY [0..2,0..2] OF Fixed;
  80.     END;
  81.  
  82.     MatrixRecordPtr = ^MatrixRecord;
  83.  
  84.     FixedPoint = RECORD
  85.         x:                        Fixed;
  86.         y:                        Fixed;
  87.     END;
  88.  
  89.     FixedRect = RECORD
  90.         left:                    Fixed;
  91.         top:                    Fixed;
  92.         right:                    Fixed;
  93.         bottom:                    Fixed;
  94.     END;
  95.  
  96. { These are the bits that are set in the Component flags, and also in the codecInfo struct. }
  97.  
  98. CONST
  99.     codecInfoDoes1                = 0+(1 * (2**(0)));
  100.     codecInfoDoes2                = 0+(1 * (2**(1)));
  101.     codecInfoDoes4                = 0+(1 * (2**(2)));
  102.     codecInfoDoes8                = 0+(1 * (2**(3)));
  103.     codecInfoDoes16                = 0+(1 * (2**(4)));
  104.     codecInfoDoes32                = 0+(1 * (2**(5)));
  105.     codecInfoDoesDither            = 0+(1 * (2**(6)));
  106.     codecInfoDoesStretch        = 0+(1 * (2**(7)));
  107.     codecInfoDoesShrink            = 0+(1 * (2**(8)));
  108.     codecInfoDoesMask            = 0+(1 * (2**(9)));
  109.     codecInfoDoesTemporal        = 0+(1 * (2**(10)));
  110.     codecInfoDoesDouble            = 0+(1 * (2**(11)));
  111.     codecInfoDoesQuad            = 0+(1 * (2**(12)));
  112.     codecInfoDoesHalf            = 0+(1 * (2**(13)));
  113.     codecInfoDoesQuarter        = 0+(1 * (2**(14)));
  114.     codecInfoDoesRotate            = 0+(1 * (2**(15)));
  115.     codecInfoDoesHorizFlip        = 0+(1 * (2**(16)));
  116.     codecInfoDoesVertFlip        = 0+(1 * (2**(17)));
  117.     codecInfoDoesSkew            = 0+(1 * (2**(18)));
  118.     codecInfoDoesBlend            = 0+(1 * (2**(19)));
  119.     codecInfoDoesWarp            = 0+(1 * (2**(20)));
  120.     codecInfoDoesRecompress        = 0+(1 * (2**(21)));
  121.     codecInfoDoesSpool            = 0+(1 * (2**(22)));
  122.     codecInfoDoesRateConstrain    = 0+(1 * (2**(23)));
  123.  
  124.     codecInfoDepth1                = 0+(1 * (2**(0)));
  125.     codecInfoDepth2                = 0+(1 * (2**(1)));
  126.     codecInfoDepth4                = 0+(1 * (2**(2)));
  127.     codecInfoDepth8                = 0+(1 * (2**(3)));
  128.     codecInfoDepth16            = 0+(1 * (2**(4)));
  129.     codecInfoDepth32            = 0+(1 * (2**(5)));
  130.     codecInfoDepth24            = 0+(1 * (2**(6)));
  131.     codecInfoDepth33            = 0+(1 * (2**(7)));
  132.     codecInfoDepth34            = 0+(1 * (2**(8)));
  133.     codecInfoDepth36            = 0+(1 * (2**(9)));
  134.     codecInfoDepth40            = 0+(1 * (2**(10)));
  135.     codecInfoStoresClut            = 0+(1 * (2**(11)));
  136.     codecInfoDoesLossless        = 0+(1 * (2**(12)));
  137.     codecInfoSequenceSensitive    = 0+(1 * (2**(13)));
  138.  
  139.     codecFlagUseImageBuffer        = 0+(1 * (2**(0)));
  140.     codecFlagUseScreenBuffer    = 0+(1 * (2**(1)));
  141.     codecFlagUpdatePrevious        = 0+(1 * (2**(2)));
  142.     codecFlagNoScreenUpdate        = 0+(1 * (2**(3)));
  143.     codecFlagWasCompressed        = 0+(1 * (2**(4)));
  144.     codecFlagDontOffscreen        = 0+(1 * (2**(5)));
  145.     codecFlagUpdatePreviousComp    = 0+(1 * (2**(6)));
  146.     codecFlagForceKeyFrame        = 0+(1 * (2**(7)));
  147.     codecFlagOnlyScreenUpdate    = 0+(1 * (2**(8)));
  148.     codecFlagLiveGrab            = 0+(1 * (2**(9)));
  149.     codecFlagDontUseNewImageBuffer = 0+(1 * (2**(10)));
  150.     codecFlagInterlaceUpdate    = 0+(1 * (2**(11)));
  151.     codecFlagCatchUpDiff        = 0+(1 * (2**(12)));
  152.     codecFlagUsedNewImageBuffer    = 0+(1 * (2**(14)));
  153.     codecFlagUsedImageBuffer    = 0+(1 * (2**(15)));
  154.  
  155. { The minimum data size for spooling in or out data }
  156.     codecMinimumDataSize        = 32768;
  157.  
  158.     compressorComponentType        = 'imco';                        { the type for "Components" which compress images }
  159.     decompressorComponentType    = 'imdc';
  160.  
  161.     
  162. TYPE
  163.     CompressorComponent = Component;
  164.  
  165.     DecompressorComponent = Component;
  166.  
  167.     CodecComponent = Component;
  168.  
  169.  
  170. CONST
  171.     anyCodec                    = 0;                            { take first working codec of given type }
  172.     bestSpeedCodec                = -1;                            { take fastest codec of given type }
  173.     bestFidelityCodec            = -2;                            { take codec which is most accurate }
  174.     bestCompressionCodec        = -3;                            { take codec of given type that is most accurate }
  175.  
  176.     
  177. TYPE
  178.     CodecType = LONGINT;
  179.  
  180.     CodecFlags = INTEGER;
  181.  
  182.     CodecQ = LONGINT;
  183.  
  184.  
  185. CONST
  186.     codecLosslessQuality        = $400;
  187.     codecMaxQuality                = $3ff;
  188.     codecMinQuality                = $000;
  189.     codecLowQuality                = $100;
  190.     codecNormalQuality            = $200;
  191.     codecHighQuality            = $300;
  192.  
  193.     codecCompletionSource        = 0+(1 * (2**(0)));                { asynchronous codec is done with source data }
  194.     codecCompletionDest            = 0+(1 * (2**(1)));                { asynchronous codec is done with destination data }
  195.  
  196.     codecProgressOpen            = 0;
  197.     codecProgressUpdatePercent    = 1;
  198.     codecProgressClose            = 2;
  199.  
  200. TYPE
  201.     ICMDataProcPtr = ProcPtr;  { FUNCTION ICMData(VAR dataP: Ptr; bytesNeeded: LONGINT; refcon: LONGINT): OSErr; }
  202.     ICMFlushProcPtr = ProcPtr;  { FUNCTION ICMFlush(data: Ptr; bytesAdded: LONGINT; refcon: LONGINT): OSErr; }
  203.     ICMCompletionProcPtr = ProcPtr;  { PROCEDURE ICMCompletion(result: OSErr; flags: INTEGER; refcon: LONGINT); }
  204.     ICMProgressProcPtr = ProcPtr;  { FUNCTION ICMProgress(message: INTEGER; completeness: Fixed; refcon: LONGINT): OSErr; }
  205.     StdPixProcPtr = ProcPtr;  { PROCEDURE StdPix(VAR src: PixMap; VAR srcRect: Rect; VAR matrix: MatrixRecord; mode: INTEGER; mask: RgnHandle; VAR matte: PixMap; VAR matteRect: Rect; flags: INTEGER); }
  206.     ICMAlignmentProcPtr = ProcPtr;  { PROCEDURE ICMAlignment(VAR rp: Rect; refcon: LONGINT); }
  207.     ICMDataUPP = UniversalProcPtr;
  208.     ICMFlushUPP = UniversalProcPtr;
  209.     ICMCompletionUPP = UniversalProcPtr;
  210.     ICMProgressUPP = UniversalProcPtr;
  211.     StdPixUPP = UniversalProcPtr;
  212.     ICMAlignmentUPP = UniversalProcPtr;
  213.  
  214.     ImageSequence = LONGINT;
  215.  
  216.     ICMProgressProcRecord = RECORD
  217.         progressProc:            ICMProgressUPP;
  218.         progressRefCon:            LONGINT;
  219.     END;
  220.  
  221.     ICMProgressProcRecordPtr = ^ICMProgressProcRecord;
  222.  
  223.     ICMCompletionProcRecord = RECORD
  224.         completionProc:            ICMCompletionUPP;
  225.         completionRefCon:        LONGINT;
  226.     END;
  227.  
  228.     ICMCompletionProcRecordPtr = ^ICMCompletionProcRecord;
  229.  
  230.     ICMDataProcRecord = RECORD
  231.         dataProc:                ICMDataUPP;
  232.         dataRefCon:                LONGINT;
  233.     END;
  234.  
  235.     ICMDataProcRecordPtr = ^ICMDataProcRecord;
  236.  
  237.     ICMFlushProcRecord = RECORD
  238.         flushProc:                ICMFlushUPP;
  239.         flushRefCon:            LONGINT;
  240.     END;
  241.  
  242.     ICMFlushProcRecordPtr = ^ICMFlushProcRecord;
  243.  
  244.     ICMAlignmentProcRecord = RECORD
  245.         alignmentProc:            ICMAlignmentUPP;
  246.         alignmentRefCon:        LONGINT;
  247.     END;
  248.  
  249.     ICMAlignmentProcRecordPtr = ^ICMAlignmentProcRecord;
  250.  
  251.     DataRateParams = RECORD
  252.         dataRate:                LONGINT;
  253.         dataOverrun:            LONGINT;
  254.         frameDuration:            LONGINT;
  255.         keyFrameRate:            LONGINT;
  256.         minSpatialQuality:        CodecQ;
  257.         minTemporalQuality:        CodecQ;
  258.     END;
  259.  
  260.     DataRateParamsPtr = ^DataRateParams;
  261.  
  262.     ImageDescription = PACKED RECORD
  263.         idSize:                    LONGINT;                                { total size of ImageDescription including extra data ( CLUTs and other per sequence data }
  264.         cType:                    CodecType;                                { what kind of codec compressed this data }
  265.         resvd1:                    LONGINT;                                { reserved for Apple use }
  266.         resvd2:                    INTEGER;                                { reserved for Apple use }
  267.         dataRefIndex:            INTEGER;                                { set to zero  }
  268.         version:                INTEGER;                                { which version is this data }
  269.         revisionLevel:            INTEGER;                                { what version of that codec did this }
  270.         vendor:                    LONGINT;                                { whose  codec compressed this data }
  271.         temporalQuality:        CodecQ;                                    { what was the temporal quality factor  }
  272.         spatialQuality:            CodecQ;                                    { what was the spatial quality factor }
  273.         width:                    INTEGER;                                { how many pixels wide is this data }
  274.         height:                    INTEGER;                                { how many pixels high is this data }
  275.         hRes:                    Fixed;                                    { horizontal resolution }
  276.         vRes:                    Fixed;                                    { vertical resolution }
  277.         dataSize:                LONGINT;                                { if known, the size of data for this image descriptor }
  278.         frameCount:                INTEGER;                                { number of frames this description applies to }
  279.         name:                    Str31;                                    { name of codec ( in case not installed )  }
  280.         depth:                    INTEGER;                                { what depth is this data (1-32) or ( 33-40 grayscale ) }
  281.         clutID:                    INTEGER;                                { clut id or if 0 clut follows  or -1 if no clut }
  282.     END;
  283.  
  284.     ImageDescriptionPtr = ^ImageDescription;
  285.     ImageDescriptionHandle = ^ImageDescriptionPtr;
  286.  
  287.     CodecInfo = PACKED RECORD
  288.         typeName:                Str31;                                    { name of the codec type i.e.: 'Apple Image Compression' }
  289.         version:                INTEGER;                                { version of the codec data that this codec knows about }
  290.         revisionLevel:            INTEGER;                                { revision level of this codec i.e: 0x00010001 (1.0.1) }
  291.         vendor:                    LONGINT;                                { Maker of this codec i.e: 'appl' }
  292.         decompressFlags:        LONGINT;                                { codecInfo flags for decompression capabilities }
  293.         compressFlags:            LONGINT;                                { codecInfo flags for compression capabilities }
  294.         formatFlags:            LONGINT;                                { codecInfo flags for compression format details }
  295.         compressionAccuracy:    UInt8;                                    { measure (1-255) of accuracy of this codec for compress (0 if unknown) }
  296.         decompressionAccuracy:    UInt8;                                    { measure (1-255) of accuracy of this codec for decompress (0 if unknown) }
  297.         compressionSpeed:        INTEGER;                                { ( millisecs for compressing 320x240 on base mac II) (0 if unknown)  }
  298.         decompressionSpeed:        INTEGER;                                { ( millisecs for decompressing 320x240 on mac II)(0 if unknown)  }
  299.         compressionLevel:        UInt8;                                    { measure (1-255) of compression level of this codec (0 if unknown)  }
  300.         resvd:                    UInt8;                                    { pad }
  301.         minimumHeight:            INTEGER;                                { minimum height of image (block size) }
  302.         minimumWidth:            INTEGER;                                { minimum width of image (block size) }
  303.         decompressPipelineLatency: INTEGER;                                { in milliseconds ( for asynchronous codecs ) }
  304.         compressPipelineLatency: INTEGER;                                { in milliseconds ( for asynchronous codecs ) }
  305.         privateData:            LONGINT;
  306.     END;
  307.  
  308.     CodecNameSpec = RECORD
  309.         codec:                    CodecComponent;
  310.         cType:                    CodecType;
  311.         typeName:                Str31;
  312.         name:                    Handle;
  313.     END;
  314.  
  315.     CodecNameSpecList = RECORD
  316.         count:                    INTEGER;
  317.         list:                    ARRAY [0..0] OF CodecNameSpec;
  318.     END;
  319.  
  320.     CodecNameSpecListPtr = ^CodecNameSpecList;
  321.  
  322.  
  323. CONST
  324.     defaultDither                = 0;
  325.     forceDither                    = 1;
  326.     suppressDither                = 2;
  327.     useColorMatching            = 4;
  328.  
  329.  
  330. TYPE
  331.     ICMFrameTimeRecord = RECORD
  332.         value:                    wide;                                    { frame time}
  333.         scale:                    LONGINT;                                { timescale of value/duration fields}
  334.         base:                    Ptr;                                    { timebase}
  335.         duration:                LONGINT;                                { duration frame is to be displayed (0 if unknown)}
  336.         rate:                    Fixed;                                    { rate of timebase relative to wall-time}
  337.     END;
  338.  
  339.     ICMFrameTimePtr = ^ICMFrameTimeRecord;
  340.  
  341.  
  342. CONST
  343.     uppICMDataProcInfo = $00000FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  344.     uppICMFlushProcInfo = $00000FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  345.     uppICMCompletionProcInfo = $00000E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param); }
  346.     uppICMProgressProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  347.     uppStdPixProcInfo = $002FEFC0; { PROCEDURE (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param, 2 byte param); }
  348.     uppICMAlignmentProcInfo = $000003C0; { PROCEDURE (4 byte param, 4 byte param); }
  349.  
  350. FUNCTION NewICMDataProc(userRoutine: ICMDataProcPtr): ICMDataUPP;
  351.     {$IFC NOT GENERATINGCFM }
  352.     INLINE $2E9F;
  353.     {$ENDC}
  354.  
  355. FUNCTION NewICMFlushProc(userRoutine: ICMFlushProcPtr): ICMFlushUPP;
  356.     {$IFC NOT GENERATINGCFM }
  357.     INLINE $2E9F;
  358.     {$ENDC}
  359.  
  360. FUNCTION NewICMCompletionProc(userRoutine: ICMCompletionProcPtr): ICMCompletionUPP;
  361.     {$IFC NOT GENERATINGCFM }
  362.     INLINE $2E9F;
  363.     {$ENDC}
  364.  
  365. FUNCTION NewICMProgressProc(userRoutine: ICMProgressProcPtr): ICMProgressUPP;
  366.     {$IFC NOT GENERATINGCFM }
  367.     INLINE $2E9F;
  368.     {$ENDC}
  369.  
  370. FUNCTION NewStdPixProc(userRoutine: StdPixProcPtr): StdPixUPP;
  371.     {$IFC NOT GENERATINGCFM }
  372.     INLINE $2E9F;
  373.     {$ENDC}
  374.  
  375. FUNCTION NewICMAlignmentProc(userRoutine: ICMAlignmentProcPtr): ICMAlignmentUPP;
  376.     {$IFC NOT GENERATINGCFM }
  377.     INLINE $2E9F;
  378.     {$ENDC}
  379.  
  380. FUNCTION CallICMDataProc(VAR dataP: Ptr; bytesNeeded: LONGINT; refcon: LONGINT; userRoutine: ICMDataUPP): OSErr;
  381.     {$IFC NOT GENERATINGCFM}
  382.     INLINE $205F, $4E90;
  383.     {$ENDC}
  384.  
  385. FUNCTION CallICMFlushProc(data: Ptr; bytesAdded: LONGINT; refcon: LONGINT; userRoutine: ICMFlushUPP): OSErr;
  386.     {$IFC NOT GENERATINGCFM}
  387.     INLINE $205F, $4E90;
  388.     {$ENDC}
  389.  
  390. PROCEDURE CallICMCompletionProc(result: OSErr; flags: INTEGER; refcon: LONGINT; userRoutine: ICMCompletionUPP);
  391.     {$IFC NOT GENERATINGCFM}
  392.     INLINE $205F, $4E90;
  393.     {$ENDC}
  394.  
  395. FUNCTION CallICMProgressProc(message: INTEGER; completeness: Fixed; refcon: LONGINT; userRoutine: ICMProgressUPP): OSErr;
  396.     {$IFC NOT GENERATINGCFM}
  397.     INLINE $205F, $4E90;
  398.     {$ENDC}
  399.  
  400. PROCEDURE CallStdPixProc(VAR src: PixMap; VAR srcRect: Rect; VAR matrix: MatrixRecord; mode: INTEGER; mask: RgnHandle; VAR matte: PixMap; VAR matteRect: Rect; flags: INTEGER; userRoutine: StdPixUPP);
  401.     {$IFC NOT GENERATINGCFM}
  402.     INLINE $205F, $4E90;
  403.     {$ENDC}
  404.  
  405. PROCEDURE CallICMAlignmentProc(VAR rp: Rect; refcon: LONGINT; userRoutine: ICMAlignmentUPP);
  406.     {$IFC NOT GENERATINGCFM}
  407.     INLINE $205F, $4E90;
  408.     {$ENDC}
  409.  
  410. FUNCTION CodecManagerVersion(VAR version: LONGINT): OSErr;
  411.     {$IFC NOT GENERATINGCFM}
  412.     INLINE $7000, $AAA3;
  413.     {$ENDC}
  414. FUNCTION GetCodecNameList(VAR list: CodecNameSpecListPtr; showAll: INTEGER): OSErr;
  415.     {$IFC NOT GENERATINGCFM}
  416.     INLINE $7001, $AAA3;
  417.     {$ENDC}
  418. FUNCTION DisposeCodecNameList(list: CodecNameSpecListPtr): OSErr;
  419.     {$IFC NOT GENERATINGCFM}
  420.     INLINE $700F, $AAA3;
  421.     {$ENDC}
  422. FUNCTION GetCodecInfo(VAR info: CodecInfo; cType: CodecType; codec: CodecComponent): OSErr;
  423.     {$IFC NOT GENERATINGCFM}
  424.     INLINE $7003, $AAA3;
  425.     {$ENDC}
  426. FUNCTION GetMaxCompressionSize(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; quality: CodecQ; cType: CodecType; codec: CompressorComponent; VAR size: LONGINT): OSErr;
  427.     {$IFC NOT GENERATINGCFM}
  428.     INLINE $7004, $AAA3;
  429.     {$ENDC}
  430. FUNCTION GetCompressionTime(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; cType: CodecType; codec: CompressorComponent; VAR spatialQuality: CodecQ; VAR temporalQuality: CodecQ; VAR compressTime: LONGINT): OSErr;
  431.     {$IFC NOT GENERATINGCFM}
  432.     INLINE $7005, $AAA3;
  433.     {$ENDC}
  434. FUNCTION CompressImage(src: PixMapHandle; {CONST}VAR srcRect: Rect; quality: CodecQ; cType: CodecType; desc: ImageDescriptionHandle; data: Ptr): OSErr;
  435.     {$IFC NOT GENERATINGCFM}
  436.     INLINE $7006, $AAA3;
  437.     {$ENDC}
  438. FUNCTION FCompressImage(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; quality: CodecQ; cType: CodecType; codec: CompressorComponent; clut: CTabHandle; flags: CodecFlags; bufferSize: LONGINT; flushProc: ICMFlushProcRecordPtr; progressProc: ICMProgressProcRecordPtr; desc: ImageDescriptionHandle; data: Ptr): OSErr;
  439.     {$IFC NOT GENERATINGCFM}
  440.     INLINE $7007, $AAA3;
  441.     {$ENDC}
  442. FUNCTION DecompressImage(data: Ptr; desc: ImageDescriptionHandle; dst: PixMapHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; mask: RgnHandle): OSErr;
  443.     {$IFC NOT GENERATINGCFM}
  444.     INLINE $7008, $AAA3;
  445.     {$ENDC}
  446. FUNCTION FDecompressImage(data: Ptr; desc: ImageDescriptionHandle; dst: PixMapHandle; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; matte: PixMapHandle; {CONST}VAR matteRect: Rect; accuracy: CodecQ; codec: DecompressorComponent; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; progressProc: ICMProgressProcRecordPtr): OSErr;
  447.     {$IFC NOT GENERATINGCFM}
  448.     INLINE $7009, $AAA3;
  449.     {$ENDC}
  450. FUNCTION CompressSequenceBegin(VAR seqID: ImageSequence; src: PixMapHandle; prev: PixMapHandle; {CONST}VAR srcRect: Rect; {CONST}VAR prevRect: Rect; colorDepth: INTEGER; cType: CodecType; codec: CompressorComponent; spatialQuality: CodecQ; temporalQuality: CodecQ; keyFrameRate: LONGINT; clut: CTabHandle; flags: CodecFlags; desc: ImageDescriptionHandle): OSErr;
  451.     {$IFC NOT GENERATINGCFM}
  452.     INLINE $700A, $AAA3;
  453.     {$ENDC}
  454. FUNCTION CompressSequenceFrame(seqID: ImageSequence; src: PixMapHandle; {CONST}VAR srcRect: Rect; flags: CodecFlags; data: Ptr; VAR dataSize: LONGINT; VAR similarity: UInt8; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  455.     {$IFC NOT GENERATINGCFM}
  456.     INLINE $700B, $AAA3;
  457.     {$ENDC}
  458. FUNCTION DecompressSequenceBegin(VAR seqID: ImageSequence; desc: ImageDescriptionHandle; port: CGrafPtr; gdh: GDHandle; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; flags: CodecFlags; accuracy: CodecQ; codec: DecompressorComponent): OSErr;
  459.     {$IFC NOT GENERATINGCFM}
  460.     INLINE $700D, $AAA3;
  461.     {$ENDC}
  462. FUNCTION DecompressSequenceBeginS(VAR seqID: ImageSequence; desc: ImageDescriptionHandle; data: Ptr; dataSize: LONGINT; port: CGrafPtr; gdh: GDHandle; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; flags: CodecFlags; accuracy: CodecQ; codec: DecompressorComponent): OSErr;
  463.     {$IFC NOT GENERATINGCFM}
  464.     INLINE $203C, $30, $5D, $AAA3;
  465.     {$ENDC}
  466. FUNCTION DecompressSequenceFrame(seqID: ImageSequence; data: Ptr; inFlags: CodecFlags; VAR outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  467.     {$IFC NOT GENERATINGCFM}
  468.     INLINE $700E, $AAA3;
  469.     {$ENDC}
  470. FUNCTION DecompressSequenceFrameS(seqID: ImageSequence; data: Ptr; dataSize: LONGINT; inFlags: CodecFlags; VAR outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  471.     {$IFC NOT GENERATINGCFM}
  472.     INLINE $203C, $16, $47, $AAA3;
  473.     {$ENDC}
  474. FUNCTION DecompressSequenceFrameWhen(seqID: ImageSequence; data: Ptr; dataSize: LONGINT; inFlags: CodecFlags; VAR outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr; {CONST}VAR frameTime: ICMFrameTimeRecord): OSErr;
  475.     {$IFC NOT GENERATINGCFM}
  476.     INLINE $203C, $1A, $5E, $AAA3;
  477.     {$ENDC}
  478. FUNCTION CDSequenceFlush(seqID: ImageSequence): OSErr;
  479.     {$IFC NOT GENERATINGCFM}
  480.     INLINE $203C, $4, $5F, $AAA3;
  481.     {$ENDC}
  482. FUNCTION SetDSequenceMatrix(seqID: ImageSequence; matrix: MatrixRecordPtr): OSErr;
  483.     {$IFC NOT GENERATINGCFM}
  484.     INLINE $7010, $AAA3;
  485.     {$ENDC}
  486. FUNCTION SetDSequenceMatte(seqID: ImageSequence; matte: PixMapHandle; {CONST}VAR matteRect: Rect): OSErr;
  487.     {$IFC NOT GENERATINGCFM}
  488.     INLINE $7011, $AAA3;
  489.     {$ENDC}
  490. FUNCTION SetDSequenceMask(seqID: ImageSequence; mask: RgnHandle): OSErr;
  491.     {$IFC NOT GENERATINGCFM}
  492.     INLINE $7012, $AAA3;
  493.     {$ENDC}
  494. FUNCTION SetDSequenceTransferMode(seqID: ImageSequence; mode: INTEGER; {CONST}VAR opColor: RGBColor): OSErr;
  495.     {$IFC NOT GENERATINGCFM}
  496.     INLINE $7013, $AAA3;
  497.     {$ENDC}
  498. FUNCTION SetDSequenceDataProc(seqID: ImageSequence; dataProc: ICMDataProcRecordPtr; bufferSize: LONGINT): OSErr;
  499.     {$IFC NOT GENERATINGCFM}
  500.     INLINE $7014, $AAA3;
  501.     {$ENDC}
  502. FUNCTION SetDSequenceAccuracy(seqID: ImageSequence; accuracy: CodecQ): OSErr;
  503.     {$IFC NOT GENERATINGCFM}
  504.     INLINE $7034, $AAA3;
  505.     {$ENDC}
  506. FUNCTION SetDSequenceSrcRect(seqID: ImageSequence; {CONST}VAR srcRect: Rect): OSErr;
  507.     {$IFC NOT GENERATINGCFM}
  508.     INLINE $7035, $AAA3;
  509.     {$ENDC}
  510. FUNCTION GetDSequenceImageBuffer(seqID: ImageSequence; VAR gworld: GWorldPtr): OSErr;
  511.     {$IFC NOT GENERATINGCFM}
  512.     INLINE $7015, $AAA3;
  513.     {$ENDC}
  514. FUNCTION GetDSequenceScreenBuffer(seqID: ImageSequence; VAR gworld: GWorldPtr): OSErr;
  515.     {$IFC NOT GENERATINGCFM}
  516.     INLINE $7016, $AAA3;
  517.     {$ENDC}
  518. FUNCTION SetCSequenceQuality(seqID: ImageSequence; spatialQuality: CodecQ; temporalQuality: CodecQ): OSErr;
  519.     {$IFC NOT GENERATINGCFM}
  520.     INLINE $7017, $AAA3;
  521.     {$ENDC}
  522. FUNCTION SetCSequencePrev(seqID: ImageSequence; prev: PixMapHandle; {CONST}VAR prevRect: Rect): OSErr;
  523.     {$IFC NOT GENERATINGCFM}
  524.     INLINE $7018, $AAA3;
  525.     {$ENDC}
  526. FUNCTION SetCSequenceFlushProc(seqID: ImageSequence; flushProc: ICMFlushProcRecordPtr; bufferSize: LONGINT): OSErr;
  527.     {$IFC NOT GENERATINGCFM}
  528.     INLINE $7033, $AAA3;
  529.     {$ENDC}
  530. FUNCTION SetCSequenceKeyFrameRate(seqID: ImageSequence; keyframerate: LONGINT): OSErr;
  531.     {$IFC NOT GENERATINGCFM}
  532.     INLINE $7036, $AAA3;
  533.     {$ENDC}
  534. FUNCTION GetCSequenceKeyFrameRate(seqID: ImageSequence; VAR keyframerate: LONGINT): OSErr;
  535.     {$IFC NOT GENERATINGCFM}
  536.     INLINE $203C, $8, $4B, $AAA3;
  537.     {$ENDC}
  538. FUNCTION GetCSequencePrevBuffer(seqID: ImageSequence; VAR gworld: GWorldPtr): OSErr;
  539.     {$IFC NOT GENERATINGCFM}
  540.     INLINE $7019, $AAA3;
  541.     {$ENDC}
  542. FUNCTION CDSequenceBusy(seqID: ImageSequence): OSErr;
  543.     {$IFC NOT GENERATINGCFM}
  544.     INLINE $701A, $AAA3;
  545.     {$ENDC}
  546. FUNCTION CDSequenceEnd(seqID: ImageSequence): OSErr;
  547.     {$IFC NOT GENERATINGCFM}
  548.     INLINE $701B, $AAA3;
  549.     {$ENDC}
  550. FUNCTION GetCompressedImageSize(desc: ImageDescriptionHandle; data: Ptr; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; VAR dataSize: LONGINT): OSErr;
  551.     {$IFC NOT GENERATINGCFM}
  552.     INLINE $701C, $AAA3;
  553.     {$ENDC}
  554. FUNCTION GetSimilarity(src: PixMapHandle; {CONST}VAR srcRect: Rect; desc: ImageDescriptionHandle; data: Ptr; VAR similarity: Fixed): OSErr;
  555.     {$IFC NOT GENERATINGCFM}
  556.     INLINE $701D, $AAA3;
  557.     {$ENDC}
  558. FUNCTION GetImageDescriptionCTable(desc: ImageDescriptionHandle; VAR ctable: CTabHandle): OSErr;
  559.     {$IFC NOT GENERATINGCFM}
  560.     INLINE $701E, $AAA3;
  561.     {$ENDC}
  562. FUNCTION SetImageDescriptionCTable(desc: ImageDescriptionHandle; ctable: CTabHandle): OSErr;
  563.     {$IFC NOT GENERATINGCFM}
  564.     INLINE $701F, $AAA3;
  565.     {$ENDC}
  566. FUNCTION GetImageDescriptionExtension(desc: ImageDescriptionHandle; VAR extension: Handle; idType: LONGINT; index: LONGINT): OSErr;
  567.     {$IFC NOT GENERATINGCFM}
  568.     INLINE $7020, $AAA3;
  569.     {$ENDC}
  570. FUNCTION SetImageDescriptionExtension(desc: ImageDescriptionHandle; extension: Handle; idType: LONGINT): OSErr;
  571.     {$IFC NOT GENERATINGCFM}
  572.     INLINE $7021, $AAA3;
  573.     {$ENDC}
  574. FUNCTION RemoveImageDescriptionExtension(VAR desc: ImageDescription; idType: LONGINT; index: LONGINT): OSErr;
  575.     {$IFC NOT GENERATINGCFM}
  576.     INLINE $203C, $C, $3A, $AAA3;
  577.     {$ENDC}
  578. FUNCTION CountImageDescriptionExtensionType(VAR desc: ImageDescription; idType: LONGINT; VAR count: LONGINT): OSErr;
  579.     {$IFC NOT GENERATINGCFM}
  580.     INLINE $203C, $C, $3B, $AAA3;
  581.     {$ENDC}
  582. FUNCTION GetNextImageDescriptionExtensionType(VAR desc: ImageDescription; VAR idType: LONGINT): OSErr;
  583.     {$IFC NOT GENERATINGCFM}
  584.     INLINE $203C, $8, $3C, $AAA3;
  585.     {$ENDC}
  586. FUNCTION FindCodec(cType: CodecType; specCodec: CodecComponent; VAR compressor: CompressorComponent; VAR decompressor: DecompressorComponent): OSErr;
  587.     {$IFC NOT GENERATINGCFM}
  588.     INLINE $7023, $AAA3;
  589.     {$ENDC}
  590. FUNCTION CompressPicture(srcPicture: PicHandle; dstPicture: PicHandle; quality: CodecQ; cType: CodecType): OSErr;
  591.     {$IFC NOT GENERATINGCFM}
  592.     INLINE $7024, $AAA3;
  593.     {$ENDC}
  594. FUNCTION FCompressPicture(srcPicture: PicHandle; dstPicture: PicHandle; colorDepth: INTEGER; clut: CTabHandle; quality: CodecQ; doDither: INTEGER; compressAgain: INTEGER; progressProc: ICMProgressProcRecordPtr; cType: CodecType; codec: CompressorComponent): OSErr;
  595.     {$IFC NOT GENERATINGCFM}
  596.     INLINE $7025, $AAA3;
  597.     {$ENDC}
  598. FUNCTION CompressPictureFile(srcRefNum: INTEGER; dstRefNum: INTEGER; quality: CodecQ; cType: CodecType): OSErr;
  599.     {$IFC NOT GENERATINGCFM}
  600.     INLINE $7026, $AAA3;
  601.     {$ENDC}
  602. FUNCTION FCompressPictureFile(srcRefNum: INTEGER; dstRefNum: INTEGER; colorDepth: INTEGER; clut: CTabHandle; quality: CodecQ; doDither: INTEGER; compressAgain: INTEGER; progressProc: ICMProgressProcRecordPtr; cType: CodecType; codec: CompressorComponent): OSErr;
  603.     {$IFC NOT GENERATINGCFM}
  604.     INLINE $7027, $AAA3;
  605.     {$ENDC}
  606. FUNCTION GetPictureFileHeader(refNum: INTEGER; VAR frame: Rect; VAR header: OpenCPicParams): OSErr;
  607.     {$IFC NOT GENERATINGCFM}
  608.     INLINE $7028, $AAA3;
  609.     {$ENDC}
  610. FUNCTION DrawPictureFile(refNum: INTEGER; {CONST}VAR frame: Rect; progressProc: ICMProgressProcRecordPtr): OSErr;
  611.     {$IFC NOT GENERATINGCFM}
  612.     INLINE $7029, $AAA3;
  613.     {$ENDC}
  614. FUNCTION DrawTrimmedPicture(srcPicture: PicHandle; {CONST}VAR frame: Rect; trimMask: RgnHandle; doDither: INTEGER; progressProc: ICMProgressProcRecordPtr): OSErr;
  615.     {$IFC NOT GENERATINGCFM}
  616.     INLINE $702E, $AAA3;
  617.     {$ENDC}
  618. FUNCTION DrawTrimmedPictureFile(srcRefnum: INTEGER; {CONST}VAR frame: Rect; trimMask: RgnHandle; doDither: INTEGER; progressProc: ICMProgressProcRecordPtr): OSErr;
  619.     {$IFC NOT GENERATINGCFM}
  620.     INLINE $702F, $AAA3;
  621.     {$ENDC}
  622. FUNCTION MakeThumbnailFromPicture(picture: PicHandle; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  623.     {$IFC NOT GENERATINGCFM}
  624.     INLINE $702A, $AAA3;
  625.     {$ENDC}
  626. FUNCTION MakeThumbnailFromPictureFile(refNum: INTEGER; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  627.     {$IFC NOT GENERATINGCFM}
  628.     INLINE $702B, $AAA3;
  629.     {$ENDC}
  630. FUNCTION MakeThumbnailFromPixMap(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  631.     {$IFC NOT GENERATINGCFM}
  632.     INLINE $702C, $AAA3;
  633.     {$ENDC}
  634. FUNCTION TrimImage(desc: ImageDescriptionHandle; inData: Ptr; inBufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; outData: Ptr; outBufferSize: LONGINT; flushProc: ICMFlushProcRecordPtr; VAR trimRect: Rect; progressProc: ICMProgressProcRecordPtr): OSErr;
  635.     {$IFC NOT GENERATINGCFM}
  636.     INLINE $702D, $AAA3;
  637.     {$ENDC}
  638. FUNCTION ConvertImage(srcDD: ImageDescriptionHandle; srcData: Ptr; colorDepth: INTEGER; clut: CTabHandle; accuracy: CodecQ; quality: CodecQ; cType: CodecType; codec: CodecComponent; dstDD: ImageDescriptionHandle; dstData: Ptr): OSErr;
  639.     {$IFC NOT GENERATINGCFM}
  640.     INLINE $7030, $AAA3;
  641.     {$ENDC}
  642. FUNCTION GetCompressedPixMapInfo(pix: PixMapPtr; VAR desc: ImageDescriptionHandle; VAR data: Ptr; VAR bufferSize: LONGINT; VAR dataProc: ICMDataProcRecord; VAR progressProc: ICMProgressProcRecord): OSErr;
  643.     {$IFC NOT GENERATINGCFM}
  644.     INLINE $7037, $AAA3;
  645.     {$ENDC}
  646. FUNCTION SetCompressedPixMapInfo(pix: PixMapPtr; desc: ImageDescriptionHandle; data: Ptr; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; progressProc: ICMProgressProcRecordPtr): OSErr;
  647.     {$IFC NOT GENERATINGCFM}
  648.     INLINE $7038, $AAA3;
  649.     {$ENDC}
  650. PROCEDURE StdPix(src: PixMapPtr; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; matte: PixMapPtr; {CONST}VAR matteRect: Rect; flags: INTEGER);
  651.     {$IFC NOT GENERATINGCFM}
  652.     INLINE $700C, $AAA3;
  653.     {$ENDC}
  654. FUNCTION TransformRgn(matrix: MatrixRecordPtr; rgn: RgnHandle): OSErr;
  655.     {$IFC NOT GENERATINGCFM}
  656.     INLINE $7039, $AAA3;
  657.     {$ENDC}
  658. {**********
  659.     preview stuff
  660. **********}
  661. PROCEDURE SFGetFilePreview(where: Point; prompt: ConstStr255Param; fileFilter: FileFilterUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; dlgHook: DlgHookUPP; VAR reply: SFReply);
  662.     {$IFC NOT GENERATINGCFM}
  663.     INLINE $7041, $AAA3;
  664.     {$ENDC}
  665. PROCEDURE SFPGetFilePreview(where: Point; prompt: ConstStr255Param; fileFilter: FileFilterUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; dlgHook: DlgHookUPP; VAR reply: SFReply; dlgID: INTEGER; filterProc: ModalFilterUPP);
  666.     {$IFC NOT GENERATINGCFM}
  667.     INLINE $7042, $AAA3;
  668.     {$ENDC}
  669. PROCEDURE StandardGetFilePreview(fileFilter: FileFilterUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; VAR reply: StandardFileReply);
  670.     {$IFC NOT GENERATINGCFM}
  671.     INLINE $7043, $AAA3;
  672.     {$ENDC}
  673. PROCEDURE CustomGetFilePreview(fileFilter: FileFilterYDUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; VAR reply: StandardFileReply; dlgID: INTEGER; where: Point; dlgHook: DlgHookYDUPP; filterProc: ModalFilterYDUPP; activeList: ActivationOrderListPtr; activateProc: ActivateYDUPP; yourDataPtr: UNIV Ptr);
  674.     {$IFC NOT GENERATINGCFM}
  675.     INLINE $7044, $AAA3;
  676.     {$ENDC}
  677. FUNCTION MakeFilePreview(resRefNum: INTEGER; progress: ICMProgressProcRecordPtr): OSErr;
  678.     {$IFC NOT GENERATINGCFM}
  679.     INLINE $7045, $AAA3;
  680.     {$ENDC}
  681. FUNCTION AddFilePreview(resRefNum: INTEGER; previewType: OSType; previewData: Handle): OSErr;
  682.     {$IFC NOT GENERATINGCFM}
  683.     INLINE $7046, $AAA3;
  684.     {$ENDC}
  685.  
  686. CONST
  687.     sfpItemPreviewAreaUser        = 11;
  688.     sfpItemPreviewStaticText    = 12;
  689.     sfpItemPreviewDividerUser    = 13;
  690.     sfpItemCreatePreviewButton    = 14;
  691.     sfpItemShowPreviewButton    = 15;
  692.  
  693.  
  694. TYPE
  695.     PreviewResourceRecord = RECORD
  696.         modDate:                LONGINT;
  697.         version:                INTEGER;
  698.         resType:                OSType;
  699.         resID:                    INTEGER;
  700.     END;
  701.  
  702.     PreviewResourcePtr = ^PreviewResourceRecord;
  703.     PreviewResource = ^PreviewResourcePtr;
  704.  
  705.  
  706. PROCEDURE AlignScreenRect(VAR rp: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  707.     {$IFC NOT GENERATINGCFM}
  708.     INLINE $203C, $8, $4C, $AAA3;
  709.     {$ENDC}
  710. PROCEDURE AlignWindow(wp: WindowPtr; front: BOOLEAN; {CONST}VAR alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  711.     {$IFC NOT GENERATINGCFM}
  712.     INLINE $203C, $E, $4D, $AAA3;
  713.     {$ENDC}
  714. PROCEDURE DragAlignedWindow(wp: WindowPtr; startPt: Point; VAR boundsRect: Rect; VAR alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  715.     {$IFC NOT GENERATINGCFM}
  716.     INLINE $203C, $14, $4E, $AAA3;
  717.     {$ENDC}
  718. FUNCTION DragAlignedGrayRgn(theRgn: RgnHandle; startPt: Point; VAR boundsRect: Rect; VAR slopRect: Rect; axis: INTEGER; actionProc: UniversalProcPtr; VAR alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr): LONGINT;
  719.     {$IFC NOT GENERATINGCFM}
  720.     INLINE $203C, $1E, $4F, $AAA3;
  721.     {$ENDC}
  722. FUNCTION SetCSequenceDataRateParams(seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
  723.     {$IFC NOT GENERATINGCFM}
  724.     INLINE $203C, $8, $50, $AAA3;
  725.     {$ENDC}
  726. FUNCTION SetCSequenceFrameNumber(seqID: ImageSequence; frameNumber: LONGINT): OSErr;
  727.     {$IFC NOT GENERATINGCFM}
  728.     INLINE $203C, $8, $51, $AAA3;
  729.     {$ENDC}
  730. FUNCTION NewImageGWorld(VAR gworld: GWorldPtr; idh: ImageDescriptionHandle; flags: GWorldFlags): QDErr;
  731.     {$IFC NOT GENERATINGCFM}
  732.     INLINE $203C, $C, $52, $AAA3;
  733.     {$ENDC}
  734. FUNCTION GetCSequenceDataRateParams(seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
  735.     {$IFC NOT GENERATINGCFM}
  736.     INLINE $203C, $8, $53, $AAA3;
  737.     {$ENDC}
  738. FUNCTION GetCSequenceFrameNumber(seqID: ImageSequence; VAR frameNumber: LONGINT): OSErr;
  739.     {$IFC NOT GENERATINGCFM}
  740.     INLINE $203C, $8, $54, $AAA3;
  741.     {$ENDC}
  742. FUNCTION GetBestDeviceRect(VAR gdh: GDHandle; VAR rp: Rect): OSErr;
  743.     {$IFC NOT GENERATINGCFM}
  744.     INLINE $203C, $8, $55, $AAA3;
  745.     {$ENDC}
  746. FUNCTION SetSequenceProgressProc(seqID: ImageSequence; VAR progressProc: ICMProgressProcRecord): OSErr;
  747.     {$IFC NOT GENERATINGCFM}
  748.     INLINE $203C, $8, $56, $AAA3;
  749.     {$ENDC}
  750. FUNCTION GDHasScale(gdh: GDHandle; depth: INTEGER; VAR scale: Fixed): OSErr;
  751.     {$IFC NOT GENERATINGCFM}
  752.     INLINE $203C, $A, $5A, $AAA3;
  753.     {$ENDC}
  754. FUNCTION GDGetScale(gdh: GDHandle; VAR scale: Fixed; VAR flags: INTEGER): OSErr;
  755.     {$IFC NOT GENERATINGCFM}
  756.     INLINE $203C, $C, $5B, $AAA3;
  757.     {$ENDC}
  758. FUNCTION GDSetScale(gdh: GDHandle; scale: Fixed; flags: INTEGER): OSErr;
  759.     {$IFC NOT GENERATINGCFM}
  760.     INLINE $203C, $A, $5C, $AAA3;
  761.     {$ENDC}
  762. FUNCTION ICMShieldSequenceCursor(seqID: ImageSequence): OSErr;
  763.     {$IFC NOT GENERATINGCFM}
  764.     INLINE $203C, $4, $62, $AAA3;
  765.     {$ENDC}
  766. PROCEDURE ICMDecompressComplete(seqID: ImageSequence; err: OSErr; flag: INTEGER; completionRtn: ICMCompletionProcRecordPtr);
  767.     {$IFC NOT GENERATINGCFM}
  768.     INLINE $203C, $C, $63, $AAA3;
  769.     {$ENDC}
  770. FUNCTION SetDSequenceTimeCode(seqID: ImageSequence; timeCodeFormat: UNIV Ptr; timeCodeTime: UNIV Ptr): OSErr;
  771.     {$IFC NOT GENERATINGCFM}
  772.     INLINE $203C, $C, $64, $AAA3;
  773.     {$ENDC}
  774.  
  775. CONST
  776.     identityMatrixType            = $00;                            { result if matrix is identity }
  777.     translateMatrixType            = $01;                            { result if matrix translates }
  778.     scaleMatrixType                = $02;                            { result if matrix scales }
  779.     scaleTranslateMatrixType    = $03;                            { result if matrix scales and translates }
  780.     linearMatrixType            = $04;                            { result if matrix is general 2 x 2 }
  781.     linearTranslateMatrixType    = $05;                            { result if matrix is general 2 x 2 and translates }
  782.     perspectiveMatrixType        = $06;                            { result if matrix is general 3 x 3 }
  783.  
  784.     
  785. TYPE
  786.     MatrixFlags = INTEGER;
  787.  
  788.  
  789. FUNCTION GetMatrixType({CONST}VAR m: MatrixRecord): INTEGER;
  790.     {$IFC NOT GENERATINGCFM}
  791.     INLINE $7014, $ABC2;
  792.     {$ENDC}
  793. PROCEDURE CopyMatrix({CONST}VAR m1: MatrixRecord; VAR m2: MatrixRecord);
  794.     {$IFC NOT GENERATINGCFM}
  795.     INLINE $7020, $ABC2;
  796.     {$ENDC}
  797. FUNCTION EqualMatrix({CONST}VAR m1: MatrixRecord; {CONST}VAR m2: MatrixRecord): BOOLEAN;
  798.     {$IFC NOT GENERATINGCFM}
  799.     INLINE $7021, $ABC2;
  800.     {$ENDC}
  801. PROCEDURE SetIdentityMatrix(VAR matrix: MatrixRecord);
  802.     {$IFC NOT GENERATINGCFM}
  803.     INLINE $7015, $ABC2;
  804.     {$ENDC}
  805. PROCEDURE TranslateMatrix(VAR m: MatrixRecord; deltaH: Fixed; deltaV: Fixed);
  806.     {$IFC NOT GENERATINGCFM}
  807.     INLINE $7019, $ABC2;
  808.     {$ENDC}
  809. PROCEDURE RotateMatrix(VAR m: MatrixRecord; degrees: Fixed; aboutX: Fixed; aboutY: Fixed);
  810.     {$IFC NOT GENERATINGCFM}
  811.     INLINE $7016, $ABC2;
  812.     {$ENDC}
  813. PROCEDURE ScaleMatrix(VAR m: MatrixRecord; scaleX: Fixed; scaleY: Fixed; aboutX: Fixed; aboutY: Fixed);
  814.     {$IFC NOT GENERATINGCFM}
  815.     INLINE $7017, $ABC2;
  816.     {$ENDC}
  817. PROCEDURE SkewMatrix(VAR m: MatrixRecord; skewX: Fixed; skewY: Fixed; aboutX: Fixed; aboutY: Fixed);
  818.     {$IFC NOT GENERATINGCFM}
  819.     INLINE $7018, $ABC2;
  820.     {$ENDC}
  821. FUNCTION TransformFixedPoints({CONST}VAR m: MatrixRecord; VAR fpt: FixedPoint; count: LONGINT): OSErr;
  822.     {$IFC NOT GENERATINGCFM}
  823.     INLINE $7022, $ABC2;
  824.     {$ENDC}
  825. FUNCTION TransformPoints({CONST}VAR mp: MatrixRecord; VAR pt1: Point; count: LONGINT): OSErr;
  826.     {$IFC NOT GENERATINGCFM}
  827.     INLINE $7023, $ABC2;
  828.     {$ENDC}
  829. FUNCTION TransformFixedRect({CONST}VAR m: MatrixRecord; VAR fr: FixedRect; VAR fpp: FixedPoint): BOOLEAN;
  830.     {$IFC NOT GENERATINGCFM}
  831.     INLINE $7024, $ABC2;
  832.     {$ENDC}
  833. FUNCTION TransformRect({CONST}VAR m: MatrixRecord; VAR r: Rect; VAR fpp: FixedPoint): BOOLEAN;
  834.     {$IFC NOT GENERATINGCFM}
  835.     INLINE $7025, $ABC2;
  836.     {$ENDC}
  837. FUNCTION InverseMatrix({CONST}VAR m: MatrixRecord; VAR im: MatrixRecord): BOOLEAN;
  838.     {$IFC NOT GENERATINGCFM}
  839.     INLINE $701C, $ABC2;
  840.     {$ENDC}
  841. PROCEDURE ConcatMatrix({CONST}VAR a: MatrixRecord; VAR b: MatrixRecord);
  842.     {$IFC NOT GENERATINGCFM}
  843.     INLINE $701B, $ABC2;
  844.     {$ENDC}
  845. PROCEDURE RectMatrix(VAR matrix: MatrixRecord; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  846.     {$IFC NOT GENERATINGCFM}
  847.     INLINE $701E, $ABC2;
  848.     {$ENDC}
  849. PROCEDURE MapMatrix(VAR matrix: MatrixRecord; {CONST}VAR fromRect: Rect; {CONST}VAR toRect: Rect);
  850.     {$IFC NOT GENERATINGCFM}
  851.     INLINE $701D, $ABC2;
  852.     {$ENDC}
  853.  
  854. {$ALIGN RESET}
  855. {$POP}
  856.  
  857. {$SETC UsingIncludes := ImageCompressionIncludes}
  858.  
  859. {$ENDC} {__IMAGECOMPRESSION__}
  860.  
  861. {$IFC NOT UsingIncludes}
  862.  END.
  863. {$ENDC}
  864.